home *** CD-ROM | disk | FTP | other *** search
/ ETO Development Tools 4 / ETO Development Tools 4.iso / Tools - Objects / MacApp / MacApp 3.0a2 / Libraries / UDesignator.cp < prev    next >
Text File  |  1991-05-01  |  15KB  |  516 lines
  1. //$P
  2. //[a-,body+,h-,o=100,r+,rec+,t=4,u+,#+,j=20/57/1$,n+]
  3. // UDesignator.cp 
  4. /* Copyright © 1984-1991 by Apple Computer Inc. All rights reserved. */
  5.  
  6. #ifndef __UGEOMETRY__
  7. #include <UGeometry.h>
  8. #endif
  9.  
  10. #ifndef __UDESIGNATOR__
  11. #include "UDesignator.h"
  12. #endif
  13.  
  14. #ifndef __USTREAM__
  15. #include <UStream.h>
  16. #endif
  17.  
  18. #ifndef __UDOCUMENT__
  19. #include <UDocument.h>
  20. #endif
  21.  
  22. #ifndef __UMACAPPUTILITIES__
  23. #include <UMacAppUtilities.h>
  24. #endif
  25.  
  26. #ifndef __UMACAPPGLOBALS__
  27. #include <UMacAppGlobals.h>
  28. #endif
  29.  
  30.  
  31. //--------------------------------------------------------------------------------------------------
  32. #pragma segment MAInit
  33.  
  34. pascal void InitUDesignator(void)
  35. {
  36.     // Suppress Linker dead stripping of these classes 
  37.     if (gDeadStripSuppression)
  38.     {
  39.         DontDeadStrip(TLinearDesignator);
  40.         DontDeadStrip(TVRectDesignator);
  41.         DontDeadStrip(TRgnDesignator);
  42.     }
  43.  
  44.     RegisterStdType("TLinearDesignator", kLinearDesignator);
  45.     RegisterStdType("TVRectDesignator", kVRectDesignator);
  46.     RegisterStdType("TRgnDesignator", kRgnDesignator);
  47. }
  48.  
  49. //--------------------------------------------------------------------------------------------------
  50. #pragma segment MADesignatorRes
  51.  
  52. pascal void TDesignator::IDesignator(TDocument* itsDocument)
  53. {
  54.     this->IObject();
  55.  
  56.     fDocument = itsDocument;
  57. }
  58.  
  59. //--------------------------------------------------------------------------------------------------
  60. #pragma segment MADesignatorRes
  61.  
  62. pascal void TDesignator::Initialize(void)        // override 
  63. {
  64.     inherited::Initialize();
  65.  
  66.     fDocument = NULL;
  67. }
  68.  
  69. //--------------------------------------------------------------------------------------------------
  70. #pragma segment MADesignatorRead
  71.  
  72. pascal void TDesignator::InitFromStream(TDocument* itsDocument,
  73.                                         TStream*/* aStream */ )
  74.  
  75. {
  76.     this->IDesignator(itsDocument);
  77. }
  78.  
  79. //--------------------------------------------------------------------------------------------------
  80. #pragma segment MADesignatorNonRes
  81.  
  82. pascal IDType TDesignator::GetSignature(void)
  83. {
  84.     // this->SubClassResponsibility();
  85.     return '    ';
  86. }
  87.  
  88. //--------------------------------------------------------------------------------------------------
  89. #pragma segment MADesignatorNonRes
  90.  
  91. pascal Size TDesignator::GetSize(void)
  92. {
  93.     // this->SubClassResponsibility();
  94.     return 0;
  95. }
  96.  
  97. //--------------------------------------------------------------------------------------------------
  98. #pragma segment MADesignatorNonRes
  99.  
  100. pascal Size TDesignator::GetSpecificationSize(void)
  101. {
  102.     // SubClassResponsibility; <= don't call this because OVERRIDE's will call INHERITED... 
  103.  
  104.     // in your GetSpecificationSize OVERRIDE, call inherited::GetSpecificationSize so that itsSize
  105.     // gets zero'd here, and then add to the returned value the incremented size needed to save your
  106.     // particular specification
  107.  
  108.     return 0;
  109. }
  110.  
  111. //--------------------------------------------------------------------------------------------------
  112. #pragma segment MADesignatorWrite
  113.  
  114. pascal void TDesignator::WriteToStream(TStream* aStream)
  115. {
  116.     // don't call SubClassResponsibility because OVERRIDE's may call INHERITED... 
  117. }
  118.  
  119. //--------------------------------------------------------------------------------------------------
  120. #pragma segment MAFields
  121.  
  122. pascal void TDesignator::Fields(TObject* obj)    // override 
  123. {
  124.     obj->DoToField("TDesignator", (Ptr)NULL, bClass);
  125.     obj->DoToField("fDocument", (Ptr) & fDocument, bObject);
  126.  
  127.     inherited::Fields(obj);
  128. }
  129.  
  130. //--------------------------------------------------------------------------------------------------
  131. #pragma segment MADesignatorNonRes
  132.  
  133. pascal ContainmentType TDesignator::IsContained(TDesignator*/* aDesignator */ )
  134. {
  135.     // this->SubclassResponsibility();
  136.     return kNotContained;
  137. }
  138.  
  139. //--------------------------------------------------------------------------------------------------
  140. #pragma segment MADesignatorRes
  141.  
  142. pascal void TLinearDesignator::ILinearDesignator(TDocument* itsDocument,
  143.                                                  long startPos,
  144.                                                  long endPos)
  145. {
  146.     this->IDesignator(itsDocument);
  147.  
  148.     fStartPos = startPos;
  149.     fEndPos = endPos;
  150. }
  151.  
  152. //--------------------------------------------------------------------------------------------------
  153. #pragma segment MADesignatorRes
  154.  
  155. pascal void TLinearDesignator::Initialize(void)    // override 
  156. {
  157.     inherited::Initialize();
  158.  
  159.     fStartPos = 0;
  160.     fEndPos = 0;
  161. }
  162.  
  163. //--------------------------------------------------------------------------------------------------
  164. #pragma segment MADesignatorNonRes
  165.  
  166. pascal IDType TLinearDesignator::GetSignature(void)
  167. {
  168.     return kLinearDesignator;
  169. }
  170.  
  171. //--------------------------------------------------------------------------------------------------
  172. #pragma segment MADesignatorNonRes
  173.  
  174. pascal Size TLinearDesignator::GetSize(void)
  175. {
  176.     return (Size)(fEndPos - fStartPos);
  177. }
  178.  
  179. //--------------------------------------------------------------------------------------------------
  180. #pragma segment MADesignatorNonRes
  181.  
  182. pascal Size TLinearDesignator::GetSpecificationSize(void)// override 
  183. {
  184.     return inherited::GetSpecificationSize() + (2 * sizeof(long));
  185. }
  186.  
  187. //--------------------------------------------------------------------------------------------------
  188. #pragma segment MADesignatorRead
  189.  
  190. pascal void TLinearDesignator::InitFromStream(TDocument* itsDocument,
  191.                                               TStream* aStream)
  192. {
  193.     long aLong;
  194.  
  195.     inherited::InitFromStream(itsDocument, aStream);
  196.  
  197.     aStream->ReadLong(aLong);
  198.     fStartPos = aLong;
  199.     aStream->ReadLong(aLong);
  200.     fEndPos = aLong;
  201. }
  202.  
  203. //--------------------------------------------------------------------------------------------------
  204. #pragma segment MADesignatorWrite
  205.  
  206. pascal void TLinearDesignator::WriteToStream(TStream* aStream)// override 
  207. {
  208.     inherited::WriteToStream(aStream);
  209.  
  210.     aStream->WriteLong(fStartPos);
  211.     aStream->WriteLong(fEndPos);
  212. }
  213.  
  214. //--------------------------------------------------------------------------------------------------
  215. #pragma segment MAFields
  216.  
  217. pascal void TLinearDesignator::Fields(TObject* obj)// override 
  218. {
  219.     obj->DoToField("TLinearDesignator", (Ptr)NULL, bClass);
  220.     obj->DoToField("fStartPos", (Ptr) & fStartPos, bLongInt);
  221.     obj->DoToField("fEndPos", (Ptr) & fEndPos, bLongInt);
  222.  
  223.     inherited::Fields(obj);
  224. }
  225.  
  226. //--------------------------------------------------------------------------------------------------
  227. #pragma segment MADesignatorNonRes
  228.  
  229. pascal ContainmentType TLinearDesignator::IsContained(TDesignator* aDesignator)
  230. {
  231.     long itsStartPos;
  232.     long itsEndPos;
  233.  
  234.     if (aDesignator && aDesignator->IsMemberClass(GetClassIDFromName("TLinearDesignator")))
  235.     {
  236.         itsStartPos = ((TLinearDesignator *)aDesignator)->fStartPos;
  237.         itsEndPos = ((TLinearDesignator *)aDesignator)->fEndPos;
  238.         if ((fStartPos <= itsStartPos) && (fEndPos >= itsEndPos))
  239.             return kFullyContained;
  240.         else if (((fStartPos <= itsStartPos) && (fEndPos < itsEndPos)) || ((fStartPos > itsStartPos) && (fEndPos >= itsEndPos)))
  241.             return kPartiallyContained;
  242.     }
  243.     return kNotContained;
  244. }
  245.  
  246. //--------------------------------------------------------------------------------------------------
  247. #pragma segment MADesignatorRes
  248.  
  249. pascal void TVRectDesignator::IVRectDesignator(TDocument* itsDocument,
  250.                                                const VRect& itsDesignation)
  251. {
  252.     this->IDesignator(itsDocument);
  253.  
  254.     fDesignation = itsDesignation;
  255. }
  256.  
  257. //--------------------------------------------------------------------------------------------------
  258. #pragma segment MADesignatorRes
  259.  
  260. pascal void TVRectDesignator::Initialize(void)    // override 
  261. {
  262.     inherited::Initialize();
  263.  
  264.     fDesignation = gZeroVRect;
  265. }
  266.  
  267. //--------------------------------------------------------------------------------------------------
  268. #pragma segment MADesignatorNonRes
  269.  
  270. pascal IDType TVRectDesignator::GetSignature(void)
  271. {
  272.     return kVRectDesignator;
  273. }
  274.  
  275. //--------------------------------------------------------------------------------------------------
  276. #pragma segment MADesignatorNonRes
  277.  
  278. pascal Size TVRectDesignator::GetSize(void)
  279. {
  280.     return (fDesignation.Length(vSel)) * (fDesignation.Length(hSel));
  281. }
  282.  
  283. //--------------------------------------------------------------------------------------------------
  284. #pragma segment MADesignatorNonRes
  285.  
  286. pascal Size TVRectDesignator::GetSpecificationSize(void)// override 
  287. {
  288.     return inherited::GetSpecificationSize() + sizeof(VRect);
  289. }
  290.  
  291. //--------------------------------------------------------------------------------------------------
  292. #pragma segment MADesignatorRead
  293.  
  294. pascal void TVRectDesignator::InitFromStream(TDocument* itsDocument,
  295.                                              TStream* aStream)
  296. {
  297.     VRect aVRect;
  298.  
  299.     inherited::InitFromStream(itsDocument, aStream);
  300.  
  301.     aStream->ReadLong(aVRect.top);
  302.     aStream->ReadLong(aVRect.left);
  303.     aStream->ReadLong(aVRect.bottom);
  304.     aStream->ReadLong(aVRect.right);
  305.     fDesignation = aVRect;
  306. }
  307.  
  308. //--------------------------------------------------------------------------------------------------
  309. #pragma segment MADesignatorWrite
  310.  
  311. pascal void TVRectDesignator::WriteToStream(TStream* aStream)// override 
  312. {
  313.     VRect aVRect;
  314.  
  315.     inherited::WriteToStream(aStream);
  316.  
  317.     aVRect = fDesignation;
  318.     aStream->WriteLong(aVRect.top);
  319.     aStream->WriteLong(aVRect.left);
  320.     aStream->WriteLong(aVRect.bottom);
  321.     aStream->WriteLong(aVRect.right);
  322. }
  323.  
  324. //--------------------------------------------------------------------------------------------------
  325. #pragma segment MAFields
  326.  
  327. pascal void TVRectDesignator::Fields(TObject* obj)// override 
  328. {
  329.     obj->DoToField("TVRectDesignator", (Ptr)NULL, bClass);
  330.     obj->DoToField("fDesignation", (Ptr) & fDesignation, bVRect);
  331.  
  332.     inherited::Fields(obj);
  333. }
  334.  
  335. //--------------------------------------------------------------------------------------------------
  336. #pragma segment MADesignatorNonRes
  337.  
  338. pascal ContainmentType TVRectDesignator::IsContained(TDesignator* aDesignator)
  339. {
  340.     VRect myVRect;
  341.     VRect itsVRect;
  342.     VRect dstRect;
  343.  
  344.     if (aDesignator && aDesignator->IsMemberClass(GetClassIDFromName("TVRectDesignator")))
  345.     {
  346.         myVRect = fDesignation;
  347.         itsVRect = ((TVRectDesignator *)aDesignator)->fDesignation;
  348.         dstRect = myVRect & itsVRect;
  349.         if (dstRect.Valid())
  350.             if (itsVRect == dstRect)
  351.                 return kFullyContained;
  352.             else
  353.                 return kPartiallyContained;
  354.     }
  355.     return kNotContained;
  356. }
  357.  
  358. //--------------------------------------------------------------------------------------------------
  359. #pragma segment MADesignatorRes
  360.  
  361. pascal void TRgnDesignator::IRgnDesignator(TDocument* itsDocument,
  362.                                            RgnHandle itsDesignation,
  363.                                            Boolean freeRgnOnFree)
  364. {
  365.     this->IDesignator(itsDocument);
  366.  
  367.     fDesignation = itsDesignation;
  368.     fFreeRgnOnFree = freeRgnOnFree;
  369. }
  370.  
  371. //--------------------------------------------------------------------------------------------------
  372. #pragma segment MADesignatorRes
  373.  
  374. pascal void TRgnDesignator::Initialize(void)    // override 
  375. {
  376.     inherited::Initialize();
  377.  
  378.     fDesignation = NULL;
  379.     fFreeRgnOnFree = TRUE;
  380. }
  381.  
  382. //--------------------------------------------------------------------------------------------------
  383. #pragma segment MADesignatorRead
  384.  
  385. pascal void TRgnDesignator::InitFromStream(TDocument* itsDocument,
  386.                                            TStream* aStream)
  387. {
  388.     long itsSize;
  389.     SignedByte savedState;
  390.  
  391.     inherited::InitFromStream(itsDocument, aStream);
  392.  
  393.     fDesignation = MakeNewRgn();
  394.  
  395.     // prepare the handle's size for the data it will receive 
  396.     itsSize = aStream->GetSize() - aStream->GetPosition();// size is stream size less curr pos 
  397.     SetHandleSize((Handle)fDesignation, itsSize);
  398.     FailMemError();
  399.  
  400.     // read in the data into the handle from the stream 
  401.     savedState = LockHandleHigh((Handle)fDesignation);
  402.     aStream->ReadBytes(*((Handle)fDesignation), itsSize);
  403.     HSetState((Handle)fDesignation, savedState);
  404. }
  405.  
  406.  
  407. //--------------------------------------------------------------------------------------------------
  408. #pragma segment MADesignatorRes
  409.  
  410. pascal TObject* TRgnDesignator::Clone(void)        // override 
  411. {
  412.     TRgnDesignator * aClonedRgnDesignator = NULL;
  413.     FailInfo fi;
  414.  
  415.     VOLATILE(aClonedRgnDesignator);
  416.  
  417.     if (fi.Try())
  418.     {
  419.         aClonedRgnDesignator = (TRgnDesignator *)inherited::Clone();
  420.         aClonedRgnDesignator->fDesignation = NULL;// so failure handler works 
  421.         aClonedRgnDesignator->fDesignation = MakeNewRgn();
  422.         CopyRgn(fDesignation, aClonedRgnDesignator->fDesignation);
  423.         fi.Success();
  424.     }
  425.     else    // Recover
  426.     {
  427.         aClonedRgnDesignator = (TRgnDesignator *)FreeIfObject(aClonedRgnDesignator);
  428.     }
  429.     return aClonedRgnDesignator;
  430. }
  431.  
  432. //--------------------------------------------------------------------------------------------------
  433. #pragma segment MADesignatorNonRes
  434.  
  435. pascal void TRgnDesignator::Free(void)            // override 
  436. {
  437.     if (fFreeRgnOnFree)
  438.         fDesignation = DisposeIfRgnHandle(fDesignation);
  439.  
  440.     inherited::Free();
  441. }
  442.  
  443. //--------------------------------------------------------------------------------------------------
  444. #pragma segment MADesignatorNonRes
  445.  
  446. pascal IDType TRgnDesignator::GetSignature(void)
  447. {
  448.     return kRgnDesignator;
  449. }
  450.  
  451. //--------------------------------------------------------------------------------------------------
  452. #pragma segment MADesignatorNonRes
  453.  
  454. pascal Size TRgnDesignator::GetSize(void)
  455. {
  456.     return (*fDesignation)->rgnSize;
  457. }
  458.  
  459. //--------------------------------------------------------------------------------------------------
  460. #pragma segment MADesignatorNonRes
  461.  
  462. pascal Size TRgnDesignator::GetSpecificationSize(void)// override 
  463. {
  464.     return inherited::GetSpecificationSize() + GetHandleSize((Handle)fDesignation);
  465. }
  466.  
  467. //--------------------------------------------------------------------------------------------------
  468. #pragma segment MADesignatorWrite
  469.  
  470. pascal void TRgnDesignator::WriteToStream(TStream* aStream)// override 
  471. {
  472.     SignedByte savedState;
  473.  
  474.     inherited::WriteToStream(aStream);
  475.  
  476.     // write the data in the handle to the stream 
  477.     savedState = LockHandleHigh((Handle)fDesignation);
  478.     aStream->WriteBytes(*((Handle)fDesignation), GetHandleSize((Handle)fDesignation));
  479.     HSetState((Handle)fDesignation, savedState);
  480. }
  481.  
  482. //--------------------------------------------------------------------------------------------------
  483. #pragma segment MAFields
  484.  
  485. pascal void TRgnDesignator::Fields(TObject* obj)// override 
  486. {
  487.     obj->DoToField("TRgnDesignator", (Ptr)NULL, bClass);
  488.     obj->DoToField("fDesignation", (Ptr) & fDesignation, bRgnHandle);
  489.     obj->DoToField("fFreeRgnOnFree", (Ptr) & fFreeRgnOnFree, bBoolean);
  490.  
  491.     inherited::Fields(obj);
  492. }
  493.  
  494. //--------------------------------------------------------------------------------------------------
  495. #pragma segment MADesignatorNonRes
  496.  
  497. pascal ContainmentType TRgnDesignator::IsContained(TDesignator* aDesignator)
  498. {
  499.     RgnHandle destRgn;
  500.     ContainmentType result = kNotContained;
  501.  
  502.     if (aDesignator && aDesignator->IsMemberClass(GetClassIDFromName("TRgnDesignator")))
  503.     {
  504.         destRgn = MakeNewRgn();
  505.         SectRgn(fDesignation, ((TRgnDesignator *)aDesignator)->fDesignation, destRgn);
  506.         if (!EmptyRgn(destRgn))
  507.             if (EqualRgn(((TRgnDesignator *)aDesignator)->fDesignation, destRgn))
  508.                 result = kFullyContained;
  509.             else
  510.                 result = kPartiallyContained;
  511.         destRgn = DisposeIfRgnHandle(destRgn);
  512.     }
  513.     return result;
  514. }
  515.  
  516.